home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / win / vb / inpgrid.exe / EXT.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-07  |  26.1 KB  |  769 lines
  1. //---------------------------------------------------------------------------
  2. // Ext.c
  3. //---------------------------------------------------------------------------
  4. // Griglia Control
  5. //---------------------------------------------------------------------------
  6.  
  7. #define NOCOMM
  8.  
  9. #include <windows.h>
  10.  
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <ctype.h>
  14. #include <dos.h>
  15. #include "vbapi.h"
  16. #include "griglia.h"
  17.  
  18. //---------------------------------------------------------------------------
  19. // RepaintGrid
  20. //---------------------------------------------------------------------------
  21. void RepaintGrid (PGRIGLIA  lpGrigliaStruct,
  22.                   BOOL      bRepaint) {
  23.  
  24.     HDC   hDC;
  25.     HFONT hOldFont;
  26.  
  27.     if (bRepaint) {    
  28.         if (hDC = GetDC (lpGrigliaStruct->hWndStatic)) {    
  29.             hOldFont = SelectObject (hDC, lpGrigliaStruct->hFont);
  30.  
  31.             PaintBackground  (lpGrigliaStruct, hDC, lpGrigliaStruct->rStatic);        
  32.             PaintTastoSu     (lpGrigliaStruct, hDC, lpGrigliaStruct->rStatic);                                
  33.             PaintHorBars     (lpGrigliaStruct, hDC, lpGrigliaStruct->rStatic);                                
  34.             PaintVertBars    (lpGrigliaStruct, hDC, lpGrigliaStruct->rStatic);
  35.  
  36.             if (hOldFont)
  37.                 SelectObject (hDC, hOldFont);
  38.             ReleaseDC(lpGrigliaStruct->hWndStatic, hDC);
  39.         }
  40.     } else {    
  41.         PaintCursor (lpGrigliaStruct);                
  42.         if (hDC = GetDC (lpGrigliaStruct->hWndStatic)) {
  43.             hOldFont = SelectObject (hDC, lpGrigliaStruct->hFont);
  44.  
  45.             PaintBlockLocal  (lpGrigliaStruct, hDC);                
  46.  
  47.             if (hOldFont)
  48.                 SelectObject (hDC, hOldFont);
  49.             ReleaseDC(lpGrigliaStruct->hWndStatic, hDC);    
  50.         }
  51.     }    
  52.     if (hDC = GetDC (lpGrigliaStruct->hWndStatic)) {    
  53.         hOldFont = SelectObject (hDC, lpGrigliaStruct->hFont);
  54.         PaintText (lpGrigliaStruct, hDC, lpGrigliaStruct->rStatic);    
  55.         PaintBlockLocal  (lpGrigliaStruct, hDC);            
  56.         ReleaseDC(lpGrigliaStruct->hWndStatic, hDC);
  57.         PaintCursor (lpGrigliaStruct);            
  58.  
  59.         if (hOldFont)
  60.             SelectObject (hDC, hOldFont);
  61.         ReleaseDC(lpGrigliaStruct->hWndStatic, hDC);        
  62.     }
  63.     SetEditText (lpGrigliaStruct,
  64.                  lpGrigliaStruct->wCursorRow,
  65.                  lpGrigliaStruct->wCursorCol);
  66. }
  67.  
  68. //---------------------------------------------------------------------------
  69. // InsertCellsText
  70. //---------------------------------------------------------------------------
  71. void InsertCellsText (PGRIGLIA  lpGrigliaStruct,
  72.                       WORD      wRow,                          
  73.                       WORD      wCol,
  74.                       WORD      wInsertCells) {      
  75.  
  76.     WORD  wRows,
  77.           wClusRows, wClusLast, wClusFirst, wClusPos,
  78.           wShift, wMove,   
  79.           nScrl;
  80.     SHORT n;
  81.     LPSTR lpPtr0, lpPtr1, lpStr;
  82.     BOOL  bRepaint = FALSE;
  83.  
  84.     wRows = lpGrigliaStruct->wRows;
  85.     for (n = 0; n < (SHORT)wInsertCells; ++n) {
  86.      
  87.         if (
  88.             (lpStr = GetCellText (lpGrigliaStruct,
  89.                                   lpGrigliaStruct->wRows - 1,
  90.                                   max (0, lpGrigliaStruct->wCols - n - 1))) &&
  91.             (_fstrlen (lpStr))
  92.            ) {
  93.                             
  94.             // Increase Total Number of Rows
  95.             wRows = lpGrigliaStruct->wRows + 
  96.                     1 + (wInsertCells - 1) / lpGrigliaStruct->wCols;
  97.             nScrl = lpGrigliaStruct->nVScrollPos;
  98.             GrigliaRows (lpGrigliaStruct, wRows);
  99.             lpGrigliaStruct->nVScrollPos = nScrl;
  100.             bRepaint = TRUE;
  101.             break;
  102.         }
  103.     }
  104.  
  105.     // Rows per Cluster
  106.     wClusRows = (ROW_CLUSTER_SIZE / (sizeof (LPSTR) *
  107.                 lpGrigliaStruct->wCols));            
  108.                       
  109.     // Last Cluster
  110.     wClusLast  = wRows / wClusRows;        
  111.     wClusFirst = wRow  / wClusRows;        
  112.                                           
  113.     // Amount to shift
  114.     wShift    =  sizeof (LPSTR) * wInsertCells;
  115.     
  116.     // Bytes to shift right
  117.     wMove     = ( wClusRows * lpGrigliaStruct->wCols - wInsertCells ) *
  118.                 sizeof (LPSTR);
  119.     
  120.     for (n = (SHORT)wClusLast; n > (SHORT)wClusFirst; --n) {
  121.                               
  122.         // shift entire row cluster    
  123.         lpPtr1 = (LPSTR)((LPLONG)lpGrigliaStruct->cRowCluster [n].lpCluster);    
  124.         _fmemmove (lpPtr1 + wShift, lpPtr1, wMove);    
  125.         
  126.         // copy shift bytes from previous row cluster        
  127.         lpPtr0 = (LPSTR)((LPLONG)lpGrigliaStruct->cRowCluster         
  128.                         [n - 1].lpCluster);     
  129.         _fmemmove (lpPtr0, lpPtr1 + wMove, wShift);    
  130.         
  131.     }                                             
  132.     
  133.     // shift first row cluster
  134.     wClusPos  = wCol +    
  135.                 (wRow - wClusFirst * wClusRows) * lpGrigliaStruct->wCols;
  136.     lpPtr1 = (LPSTR)((LPLONG)lpGrigliaStruct->cRowCluster [wClusFirst].lpCluster +
  137.                              wClusPos);        
  138.     _fmemmove (lpPtr1 + wShift,
  139.                lpPtr1,
  140.                wMove - (wRow * lpGrigliaStruct->wCols + wCol) * sizeof (LPSTR));
  141.     _fmemset  (lpPtr1, 0, wShift); 
  142.  
  143.     RepaintGrid (lpGrigliaStruct, bRepaint);
  144. }        
  145.         
  146. //---------------------------------------------------------------------------
  147. // LineBreakText
  148. //---------------------------------------------------------------------------
  149. void LineBreakText (PGRIGLIA  lpGrigliaStruct,
  150.                     WORD      wRow,
  151.                     WORD      wCol) {
  152.  
  153.     InsertCellsText (lpGrigliaStruct,
  154.                      wRow,
  155.                      wCol,
  156.                      lpGrigliaStruct->wCols - wCol);
  157. }
  158.  
  159. //---------------------------------------------------------------------------
  160. // DeleteCellsText
  161. //---------------------------------------------------------------------------
  162. void DeleteCellsText (PGRIGLIA  lpGrigliaStruct,
  163.                       WORD      wRow,                          
  164.                       WORD      wCol,
  165.                       WORD      wDeleteCells) {
  166.  
  167.     WORD  wRows,
  168.           wClusRows, wClusLast, wClusFirst, wClusPos,
  169.           wShift, wMove,   
  170.           nScrl;
  171.     SHORT n;
  172.     LPSTR lpPtr0, lpPtr1, lpStr;
  173.     BOOL  bRepaint = TRUE;
  174.  
  175.     // Rows per Cluster
  176.     wClusRows = (ROW_CLUSTER_SIZE / (sizeof (LPSTR) *
  177.                 lpGrigliaStruct->wCols));            
  178.                       
  179.     // Last Cluster
  180.     wClusLast  = lpGrigliaStruct->wRows / wClusRows;
  181.     wClusFirst = wRow  / wClusRows;        
  182.                                           
  183.     // Amount to shift
  184.     wShift    =  sizeof (LPSTR) * wDeleteCells;
  185.     
  186.     // Bytes to shift left
  187.     wMove     = ( wClusRows * lpGrigliaStruct->wCols - wDeleteCells ) *
  188.                 sizeof (LPSTR);
  189.  
  190.     // shift first row cluster
  191.     wClusPos  = wCol +    
  192.                 (wRow - wClusFirst * wClusRows) * lpGrigliaStruct->wCols;
  193.     lpPtr0 = (LPSTR)((LPLONG)lpGrigliaStruct->cRowCluster [wClusFirst].lpCluster);
  194.     lpPtr1 = (LPSTR)((LPLONG)lpGrigliaStruct->cRowCluster [wClusFirst].lpCluster +
  195.                              wClusPos);        
  196.     _fmemmove (lpPtr1,
  197.                lpPtr1 + wShift,
  198.                wMove - (wRow * lpGrigliaStruct->wCols + wCol) * sizeof (LPSTR));
  199.     _fmemset  (lpPtr0 + wMove, 0, wShift);
  200.  
  201.     // shift other clusters
  202.     for (n = (SHORT)wClusFirst + 1; n < (SHORT)wClusLast; ++n) {
  203.  
  204.         // copy shift bytes to previous row cluster
  205.         lpPtr0 = (LPSTR)((LPLONG)lpGrigliaStruct->cRowCluster         
  206.                          [n - 1].lpCluster);
  207.         _fmemmove (lpPtr0 + wMove, lpPtr1, wShift);
  208.  
  209.         // shift entire row cluster    
  210.         lpPtr1 = (LPSTR)((LPLONG)lpGrigliaStruct->cRowCluster [n].lpCluster);    
  211.         _fmemmove (lpPtr1, lpPtr1 + wShift, wMove);
  212.         _fmemset  (lpPtr1 + wMove, 0, wShift);
  213.     }
  214.  
  215.     // need to decrease total number of rows ?
  216.     for (n = (SHORT)lpGrigliaStruct->wCols - 1;
  217.          n >= 0;
  218.          --n) {
  219.         if (
  220.             (lpStr = GetCellText (lpGrigliaStruct,
  221.                                   lpGrigliaStruct->wRows - 1,
  222.                                   n)) &&
  223.             (_fstrlen (lpStr))
  224.            ) {
  225.             bRepaint = FALSE;
  226.             break;
  227.         }
  228.     }
  229.     if (bRepaint) {
  230.         // Decrease Total Number of Rows
  231.         wRows = lpGrigliaStruct->wRows -
  232.                 1 - (wDeleteCells - 1) / lpGrigliaStruct->wCols;
  233.         nScrl = lpGrigliaStruct->nVScrollPos;
  234.         GrigliaRows (lpGrigliaStruct, wRows);
  235.         lpGrigliaStruct->nVScrollPos = nScrl;
  236.     }
  237.  
  238.     RepaintGrid (lpGrigliaStruct, bRepaint);
  239. }
  240.  
  241. //---------------------------------------------------------------------------
  242. // RemoveLineBreakText
  243. //---------------------------------------------------------------------------
  244. void RemoveLineBreakText (PGRIGLIA  lpGrigliaStruct,
  245.                           WORD      wRow,
  246.                           WORD      wCol) {
  247.  
  248.     WORD  wDeleteCells = 0;
  249.     SHORT n;
  250.     LPSTR lpStr;
  251.  
  252.     if (wRow < lpGrigliaStruct->wRows - 1) {
  253.         for (n = (SHORT)lpGrigliaStruct->wCols - 1; n >= (SHORT)wCol; --n) {
  254.             ++wDeleteCells;
  255.             if (
  256.                 (lpStr = GetCellText (lpGrigliaStruct, wRow, n)) &&
  257.                 (_fstrlen (lpStr))
  258.                )
  259.                 break;
  260.         }
  261.         if (wDeleteCells)
  262.             DeleteCellsText (lpGrigliaStruct,
  263.                             wRow,
  264.                             wCol,
  265.                             wDeleteCells);
  266.  
  267.     }
  268. }
  269.  
  270. //---------------------------------------------------------------------------
  271. // MoveWordRight
  272. //---------------------------------------------------------------------------
  273. void MoveWordTextRight (PGRIGLIA  lpGrigliaStruct,
  274.                         WORD      wRow,
  275.                         WORD      wCol) {
  276.  
  277.     HANDLE hStr, hRight;
  278.     PSTR   pStr, pRight;
  279.     LPSTR  lpStr, lpRight, lpToken, lpLoop;
  280.     WORD   nStrLen, nRightLen, nTokenLen;
  281.     WORD   wRightCol = 0xffff;
  282.     WORD   wRightRow = 0xffff;
  283.  
  284.     // Determine Right Column
  285.     if (wCol < lpGrigliaStruct->wCols - 1) {
  286.         wRightCol = wCol + 1;
  287.         wRightRow = wRow;
  288.     } else if (
  289.                (wCol == lpGrigliaStruct->wCols - 1) &&
  290.                (wRow < lpGrigliaStruct->wRows - 1)
  291.               ) {
  292.         wRightCol = 0;
  293.         wRightRow = wRow + 1;
  294.     }
  295.  
  296.     // Parse text of current cell
  297.     if (
  298.         (wRightRow != 0xffff)                                &&
  299.         (wRightCol != 0xffff)                                &&
  300.         (lpStr   = GetCellText (lpGrigliaStruct, wRow, wCol)) &&
  301.         (nStrLen = _fstrlen (lpStr))
  302.        ) {
  303.         if ( hStr = LocalAlloc (LHND,
  304.                                 nStrLen + 3) ) {
  305.             pStr = (PSTR) LocalLock (hStr);
  306.             _fstrcpy (pStr, lpStr);
  307.  
  308.             // get last word
  309.             lpToken   = _fstrtok ( pStr, " \t\n");
  310.             while (lpLoop = _fstrtok (NULL, " \t\n"))
  311.                 lpToken = lpLoop;
  312.  
  313.             nTokenLen = 0;
  314.             if (lpToken)
  315.                 nTokenLen = _fstrlen (lpToken);
  316.  
  317.             if (nTokenLen) {
  318.                 // get left word
  319.                 nRightLen = 0;
  320.                 if (lpRight = GetCellText (lpGrigliaStruct, wRightRow, wRightCol))
  321.                     nRightLen = _fstrlen (lpRight);
  322.  
  323.                 // prepend token to right word
  324.                 if ( hRight = LocalAlloc (LHND,
  325.                                           nRightLen + nTokenLen + 3) ) {
  326.  
  327.                     pRight = (PSTR) LocalLock (hRight);
  328.                     *pRight = 0;
  329.                     if (nTokenLen)
  330.                         _fstrcat (pRight, lpToken);
  331.                     if (
  332.                         (nRightLen) &&
  333.                         (nTokenLen)
  334.                        )
  335.                         _fstrcat (pRight, " ");
  336.                     if (nRightLen)
  337.                         _fstrcat (pRight, lpRight);
  338.                     PutCellText (lpGrigliaStruct, wRightRow, wRightCol, pRight);
  339.  
  340.                     LocalUnlock (hRight);
  341.                     LocalFree   (hRight);
  342.                 }
  343.  
  344.                 // remove token from cell text
  345.                 if (nTokenLen == nStrLen)
  346.                     PutCellText (lpGrigliaStruct, wRow, wCol, "");
  347.                 else if (nStrLen > nTokenLen) {
  348.                     // write rest of string back - find last char
  349.                     _fstrcpy (pStr, lpStr);
  350.  
  351.                     *lpToken-- = 0;
  352.                     while ((LPSTR)pStr < lpToken) {
  353.                         if (
  354.                             (*lpToken != ' ')  &&
  355.                             (*lpToken != '\t') &&
  356.                             (*lpToken != '\n')
  357.                            )
  358.                             break;
  359.                         *lpToken-- = 0;
  360.                     }
  361.                     if (
  362.                         (pStr) &&
  363.                         (_fstrlen (pStr))
  364.                        )
  365.                         PutCellText (lpGrigliaStruct, wRow, wCol, pStr);
  366.                 }
  367.  
  368.                 // paint grid
  369.                 RepaintGrid (lpGrigliaStruct, FALSE);
  370.  
  371.             }
  372.             LocalUnlock (hStr);
  373.             LocalFree   (hStr);
  374.         }
  375.     }
  376. }
  377.  
  378. //---------------------------------------------------------------------------
  379. // MoveWordLeft
  380. //---------------------------------------------------------------------------
  381. void MoveWordTextLeft (PGRIGLIA  lpGrigliaStruct,
  382.                        WORD      wRow,
  383.                        WORD      wCol) {
  384.  
  385.     HANDLE hStr, hLeft;
  386.     PSTR   pStr, pLeft;
  387.     LPSTR  lpStr, lpLeft, lpToken;
  388.     WORD   nStrLen, nLeftLen, nTokenLen;
  389.     WORD   wLeftCol = 0xffff;
  390.     WORD   wLeftRow = 0xffff;
  391.  
  392.     // Determine Left Column
  393.     if (wCol > 0) {
  394.         wLeftCol = wCol - 1;
  395.         wLeftRow = wRow;
  396.     } else if (
  397.              (wCol == 0) &&
  398.              (wRow > lpGrigliaStruct->wFixedRows)
  399.             ) {
  400.         wLeftCol = lpGrigliaStruct->wCols - 1;
  401.         wLeftRow = wRow - 1;
  402.     }
  403.  
  404.     // Parse text of current cell
  405.     if (
  406.         (wLeftRow != 0xffff)                                &&
  407.         (wLeftCol != 0xffff)                                &&
  408.         (lpStr   = GetCellText (lpGrigliaStruct, wRow, wCol)) &&
  409.         (nStrLen = _fstrlen (lpStr))
  410.        ) {
  411.         if ( hStr = LocalAlloc (LHND,
  412.                                 nStrLen + 3) ) {
  413.             pStr = (PSTR) LocalLock (hStr);
  414.             _fstrcpy (pStr, lpStr);
  415.  
  416.             // get first word
  417.             lpToken   = _fstrtok ( pStr, " \t\n");
  418.             nTokenLen = 0;
  419.             if (lpToken)
  420.                 nTokenLen = _fstrlen (lpToken);
  421.  
  422.             if (nTokenLen) {
  423.                 // get left word
  424.                 nLeftLen = 0;
  425.                 if (lpLeft = GetCellText (lpGrigliaStruct, wLeftRow, wLeftCol))
  426.                     nLeftLen = _fstrlen (lpLeft);
  427.  
  428.                 // append token to left word
  429.                 if ( hLeft = LocalAlloc (LHND,
  430.                                          nLeftLen + nTokenLen + 3) ) {
  431.  
  432.                     pLeft = (PSTR) LocalLock (hLeft);
  433.                     *pLeft = 0;
  434.                     if (nLeftLen)
  435.                         _fstrcat (pLeft, lpLeft);
  436.                     if (
  437.                         (nLeftLen) &&
  438.                         (nTokenLen)
  439.                        )
  440.                         _fstrcat (pLeft, " ");
  441.                     if (nTokenLen)
  442.                         _fstrcat (pLeft, lpToken);
  443.                     PutCellText (lpGrigliaStruct, wLeftRow, wLeftCol, pLeft);
  444.  
  445.                     LocalUnlock (hLeft);
  446.                     LocalFree   (hLeft);
  447.                 }
  448.  
  449.                 // remove token from cell text
  450.                 if (nTokenLen == nStrLen)
  451.                     PutCellText (lpGrigliaStruct, wRow, wCol, "");
  452.                 else if (nStrLen > nTokenLen) {
  453.                     // write rest of string back - find first char
  454.                     pStr += nTokenLen + 1;
  455.                     while (*pStr) {
  456.                         if (
  457.                             (*pStr != ' ')  &&
  458.                             (*pStr != '\t') &&
  459.                             (*pStr != '\n')
  460.                            )
  461.                             break;
  462.                         ++pStr;
  463.                     }
  464.                     if (
  465.                         (pStr) &&
  466.                         (_fstrlen (pStr))
  467.                        )
  468.                         PutCellText (lpGrigliaStruct, wRow, wCol, pStr);
  469.                 }
  470.  
  471.                 // paint grid
  472.                 RepaintGrid (lpGrigliaStruct, FALSE);
  473.  
  474.             }
  475.             LocalUnlock (hStr);
  476.             LocalFree   (hStr);
  477.         }
  478.     }
  479. }
  480.  
  481. //---------------------------------------------------------------------------
  482. // ShiftWordLeft
  483. //---------------------------------------------------------------------------
  484. void ShiftWordTextLeft (PGRIGLIA  lpGrigliaStruct,
  485.                         WORD      wRow,
  486.                         WORD      wCol) {
  487.  
  488.     LPSTR  lpStr;
  489.     WORD   wLeftCol = 0xffff;
  490.     WORD   wLeftRow = 0xffff;
  491.  
  492.     if (
  493.         (lpStr   = GetCellText (lpGrigliaStruct, wRow, wCol)) &&
  494.         (_fstrlen (lpStr))
  495.        ) {
  496.  
  497.         // Determine Left Column
  498.         if (wCol > 0) {
  499.             wLeftCol = wCol - 1;
  500.             wLeftRow = wRow;
  501.         } else if (
  502.                    (wCol == 0) &&
  503.                    (wRow > lpGrigliaStruct->wFixedRows)
  504.                   ) {
  505.             wLeftCol = lpGrigliaStruct->wCols - 1;
  506.             wLeftRow = wRow - 1;
  507.         }
  508.  
  509.         MoveWordTextLeft (lpGrigliaStruct, wRow, wCol);
  510.         if (
  511.             (!(lpStr = GetCellText (lpGrigliaStruct, wRow, wCol))) ||
  512.             (!_fstrlen (lpStr))
  513.         )
  514.             DeleteCellsText (lpGrigliaStruct, wRow, wCol, 1);
  515.     }
  516. }
  517.  
  518. //---------------------------------------------------------------------------
  519. // ShiftWordRight
  520. //---------------------------------------------------------------------------
  521. void ShiftWordTextRight (PGRIGLIA  lpGrigliaStruct,
  522.                          WORD      wRow,
  523.                          WORD      wCol) {
  524.  
  525.     LPSTR  lpStr, lpRight;
  526.     WORD   wRightCol = 0xffff;
  527.     WORD   wRightRow = 0xffff;
  528.  
  529.     if (
  530.         (lpStr   = GetCellText (lpGrigliaStruct, wRow, wCol)) &&
  531.         (_fstrlen (lpStr))
  532.        ) {
  533.  
  534.         // Determine Right Column
  535.         if (wCol < lpGrigliaStruct->wCols - 1) {
  536.             wRightCol = wCol + 1;
  537.             wRightRow = wRow;
  538.         } else if (
  539.                    (wCol == lpGrigliaStruct->wCols - 1) &&
  540.                    (wRow < lpGrigliaStruct->wRows - 1)
  541.                   ) {
  542.             wRightCol = 0;
  543.             wRightRow = wRow + 1;
  544.         }
  545.  
  546.         if (
  547.             (
  548.              (lpRight = GetCellText (lpGrigliaStruct, wRightRow, wRightCol)) &&
  549.              (_fstrlen (lpRight))
  550.             ) ||
  551.             (
  552.              (wRow == lpGrigliaStruct->wRows - 1) &&
  553.              (wCol == lpGrigliaStruct->wCols - 1)
  554.             )
  555.            )
  556.             InsertCellsText (lpGrigliaStruct,
  557.                             wRightRow,
  558.                             wRightCol,
  559.                             1);
  560.  
  561.         MoveWordTextRight (lpGrigliaStruct, wRow, wCol);
  562.     }
  563. }
  564.  
  565. //---------------------------------------------------------------------------
  566. // Just
  567. //---------------------------------------------------------------------------
  568. void Just (PGRIGLIA lpGrigliaStruct,
  569.            WORD     wTop,
  570.            WORD     wLeft,
  571.            WORD     wBottom,
  572.            WORD     wRight,
  573.            BYTE     byJust) {
  574.  
  575.     UINT  nTotLength,
  576.           nLength,
  577.           nBlanks;
  578.     SHORT m, n;
  579.     LPSTR lpText;
  580.     HANDLE hStr;
  581.     PSTR  pStr;
  582.  
  583.     for (n = (SHORT) wLeft; n <= (SHORT) wRight; ++n) {
  584.  
  585.         nTotLength = 0;
  586.         for (m = (SHORT) wTop; m <= (SHORT) wBottom; ++m) {
  587.             if (lpText = GetCellText (lpGrigliaStruct, m, n)) {
  588.  
  589.                 // remove initial blanks
  590.                 while (
  591.                        (*lpText)        &&
  592.                        (*lpText == ' ')
  593.                       )
  594.                     ++lpText;
  595.  
  596.                 // remove final blanks
  597.                 while (
  598.                        (lpText)                       &&
  599.                        (nLength  = _fstrlen (lpText)) &&
  600.                        (*(lpText + nLength - 1) == ' ')
  601.                       )
  602.                     *(lpText + nLength - 1) = 0;
  603.  
  604.                 nTotLength = max (nTotLength, _fstrlen (lpText));
  605.             }
  606.         }
  607.  
  608.         if (nTotLength)
  609.             for (m = (SHORT) wTop; m <= (SHORT) wBottom; ++m) {
  610.  
  611.             // get existing text
  612.             if (lpText = GetCellText (lpGrigliaStruct, m, n)) {
  613.  
  614.                 // remove initial blanks
  615.                 while (
  616.                        (*lpText)        &&
  617.                        (*lpText == ' ')
  618.                       )
  619.                     ++lpText;
  620.  
  621.                 // determine how many blanks to prepend
  622.                 if (
  623.                     (lpText) &&
  624.                     (nLength = _fstrlen (lpText))
  625.                    ) {
  626.                     nBlanks = 0;
  627.                     if (
  628.                         (byJust == CENTER_JUST) &&
  629.                         (nTotLength >= nLength)
  630.                        )
  631.                         nBlanks = (nTotLength - nLength) / 2;
  632.                     else if (byJust == LEFT_JUST)
  633.                         nBlanks = 0;
  634.                     else if (
  635.                              (byJust == RIGHT_JUST) &&
  636.                              (nTotLength >= nLength)
  637.                             )
  638.                         nBlanks = nTotLength - nLength;
  639.  
  640.                     // prepend blanks
  641.                     if ( hStr = LocalAlloc (LHND,
  642.                                             nBlanks + nLength + 3) ) {
  643.  
  644.                         pStr = LocalLock (hStr);
  645.  
  646.                         _fmemset (pStr, 0, nBlanks + nLength + 1);
  647.                         if (nBlanks)
  648.                             _fmemset (pStr, ' ', nBlanks);
  649.  
  650.                         _fmemcpy (pStr + nBlanks, lpText, nLength);
  651.  
  652.                         PutCellText (lpGrigliaStruct,
  653.                                      m, n,
  654.                                      pStr);
  655.  
  656.                         LocalUnlock (hStr);
  657.                         LocalFree   (hStr);
  658.                     }
  659.                 }
  660.             }
  661.         }
  662.     }
  663.  
  664.     // paint grid
  665.     RepaintGrid (lpGrigliaStruct, FALSE);
  666. }
  667.  
  668. //---------------------------------------------------------------------------
  669. // PaintTextCell_Ext
  670. //---------------------------------------------------------------------------
  671. BOOL PaintTextCell_Ext (HDC         hDC,
  672.                         RECT        rRect,
  673.                         LPEXT_INPUT lpExt,
  674.                         LPSTR       lpStr) {
  675.  
  676.     COLORREF rgbOldFColor, rgbOldBColor;
  677.     UINT     bRet, nLen;
  678.     RECT     rTemp;
  679.     static   LOGFONT  lfFont;
  680.     HFONT    hOldFont, hFont = 0;
  681.  
  682.     lfFont.lfHeight         = 12;
  683.     lfFont.lfWidth          = 0;
  684.     lfFont.lfEscapement     = 0;
  685.     lfFont.lfOrientation    = 0;
  686.     lfFont.lfWeight         = FW_NORMAL;
  687.     lfFont.lfItalic         = 0;
  688.     lfFont.lfUnderline      = 0;
  689.     lfFont.lfStrikeOut      = 0;
  690.     lfFont.lfCharSet        = ANSI_CHARSET;
  691.     lfFont.lfOutPrecision   = OUT_DEFAULT_PRECIS;
  692.     lfFont.lfClipPrecision  = CLIP_DEFAULT_PRECIS;
  693.     lfFont.lfQuality        = DEFAULT_QUALITY;
  694.     lfFont.lfPitchAndFamily = DEFAULT_PITCH;
  695.     _fstrcpy (lfFont.lfFaceName, "Courier New");
  696.  
  697.     if (
  698.         (lpStr)           &&
  699.         (nLen = _fstrlen (lpStr))
  700.        ) {
  701.         rgbOldFColor = 0;
  702.         if (lpExt->rgbFColor)
  703.             rgbOldFColor = SetTextColor (hDC, lpExt->rgbFColor);
  704.         rgbOldBColor = 0;
  705.         if (lpExt->rgbBColor)
  706.             rgbOldBColor = SetBkColor (hDC, lpExt->rgbBColor);
  707.  
  708.         if (
  709.             (lpExt->bySize) ||
  710.             (lpExt->lpFaceName) ||
  711.             (lpExt->uStatus & BOLD) ||
  712.             (lpExt->uStatus & ITALIC) ||
  713.             (lpExt->uStatus & UNDERLINE)
  714.            ) {
  715.             if (lpExt->bySize)
  716.                 lfFont.lfHeight = lpExt->bySize;
  717.             if (lpExt->lpFaceName)
  718.                 _fstrcpy (lfFont.lfFaceName, lpExt->lpFaceName);
  719.             if (lpExt->uStatus & BOLD)
  720.                 lfFont.lfWeight = FW_BOLD;
  721.             if (lpExt->uStatus & ITALIC)
  722.                 lfFont.lfItalic = 1;
  723.             if (lpExt->uStatus & UNDERLINE)
  724.                 lfFont.lfUnderline = 1;
  725.  
  726.             if (hFont = CreateFontIndirect ((const LOGFONT FAR *)&lfFont))
  727.                 hOldFont = SelectObject (hDC, hFont);
  728.         }
  729.  
  730.         // paint whole background
  731.         rTemp = rRect;
  732.         InflateRect ((LPRECT) &rTemp, SMALL_RIM, SMALL_RIM);
  733.         bRet = ExtTextOut ( hDC,
  734.                             rRect.left, rRect.top,
  735.                             ETO_CLIPPED | ETO_OPAQUE,
  736.                             (LPRECT)&rTemp,
  737.                             "", 1,
  738.                             (LPINT)NULL);
  739.  
  740.         // paint rules
  741.         {
  742.             HPEN hOldPen;
  743.  
  744.             hOldPen = SelectObject (hDC, hDashedPen);
  745.             MoveTo (hDC, rTemp.left,  rTemp.top);
  746.             LineTo (hDC, rTemp.right, rTemp.top);
  747.             LineTo (hDC, rTemp.right, rTemp.bottom);
  748.             LineTo (hDC, rTemp.left,  rTemp.bottom);
  749.             LineTo (hDC, rTemp.left,  rTemp.top);
  750.             SelectObject (hDC, hOldPen);
  751.         }
  752.  
  753.         bRet = ExtTextOut ( hDC,
  754.                             rRect.left, rRect.top,
  755.                             ETO_CLIPPED | ETO_OPAQUE,
  756.                             (LPRECT)&rRect,
  757.                             lpStr, nLen,
  758.                             (LPINT)NULL);
  759.  
  760.         SetTextColor (hDC, rgbOldFColor);
  761.         SetBkColor   (hDC, rgbOldBColor);
  762.         if (hOldFont)
  763.             SelectObject (hDC, hOldFont);
  764.         if (hFont)
  765.             DeleteObject (hFont);
  766.     }
  767.     return (bRet);
  768. }
  769.